package cradleofrome;
import java.lang.Math;
/**
 *
 * @author Alex
 */
public class Spelveld {

    private Positie[][] posities;
    private Selector selektor;
    private int veldGroot_y;
    private int veldGroot_x;

    /**
     * Constructor voor spelveld
     * @param aantal dat in het spelveld worden gemaakt
     * @param x het grootte van de veld in de X richting
     * @param y het grootte van de veld in de Y richting
     */
    public Spelveld(int x, int y, int aantal){

        veldGroot_y = y;
        veldGroot_x = x;
        posities = new Positie[x][y];
        createPosities();
        createSelector();
        createSpelobjecten(aantal);
    }

    /**
     * Constructor voor de JUnit test
     */
        public Spelveld(){

        veldGroot_y = 10;
        veldGroot_x = 10;
        posities = new Positie[veldGroot_y][veldGroot_x];
        createPosities();
        createSelector();
        new beweegbaarObject(posities[4][5]);
        new nietBeweegbaarObject(posities[6][5]);
    }

    /**
     * Maakt alle posities in het veld aan en geeft ze de juiste buren
     */
    private void createPosities(){

        //Maak alle posities aan en zet ze op de juiste coordinaat
        for(int y = 0; y < veldGroot_y; y++){
            for(int x = 0; x < veldGroot_x; x++){

                     posities[x][y] = new Positie(x, y);
            }
        }
        
        //Set voor alle posities de buren
        for (int y = 0; y < veldGroot_y; y++){
            for(int x = 0; x < veldGroot_x; x++){

                if(x > 0){

                    posities[x][y].setBuur("links", posities[x-1][y]);
                    }
                else{
                
                    posities[x][y].setBuur("links", null);
                }
                
                System.out.println("links set");

                if(x < (veldGroot_x - 1)){

                    posities[x][y].setBuur("rechts", posities[x+1][y]);
                     }
                 else{

                    posities[x][y].setBuur("rechts", null);
                }
                System.out.println("rechts set");

                if(y > 0){

                    posities[x][y].setBuur("boven", posities[x][y-1]);
                    }
                 else{

                    posities[x][y].setBuur("boven", null);
                }
                System.out.println("boven set");

                if(y < (veldGroot_y - 1)){

                    posities[x][y].setBuur("beneden", posities[x][y+1]);
                }
                 else{

                    posities[x][y].setBuur("beneden", null);
                }
                System.out.println("beneden set");
            }
        }
    }
    
    /**
     * Maakt willekeurig Spelobjecten aan en plaats deze in het spelveld
     * @param aantalObjecten het aantal Spelobjecten dat aangemaakt moet worden
     */
    private void createSpelobjecten(int aantalSpelobjecten){


        int teller = 0;

        //Maakt alle beweegbare Spelobjecten aan
        while(teller < aantalSpelobjecten){

            int x = (int)(1 + Math.random() * veldGroot_x);
            int y = (int)(1 + Math.random() * veldGroot_y);

            if(posities[x-1][y-1].getSpelobject() == null && posities[x-1][y-1].getSelector() == null){

                new beweegbaarObject(posities[x - 1][y - 1]);
                System.out.println("Beweegbare Spelobject gemaakt op Y: " + (y - 1)+ " X: " + (x - 1));
                teller++;
            }
        }
        teller = 0;

        //Maakt voor elke 5 beweegbare Spelobjecten 1 niet beweegbare Spelobjecten aan
        while(teller < (aantalSpelobjecten /5)){

            int x = (int)(1 + Math.random() * veldGroot_x);
            int y = (int)(1 + Math.random() * veldGroot_y);

            if(posities[x-1][y-1].getSpelobject() == null && posities[x-1][y-1].getSelector() == null){

                new nietBeweegbaarObject(posities[x - 1][y - 1]);
                System.out.println("niet Beweegbare Spelobject gemaakt op Y: " + (y - 1)+ " X: " + (x - 1));
                teller++;
            }
        }
    }
    
    /**
     * Maakt de selector aan het en plaats in het midden vah het spelveld
     */
    private void createSelector(){

        selektor = new Selector(posities[ (veldGroot_x / 2) ][ (veldGroot_y / 2) ]);
    }
    
    /**
     * Haalt een positie uit de array van posities
     * @param x coordinaat van de positie
     * @param y coordinaat van de positie
     * @return de positie object
     */
    public Positie getPositie(int x, int y){

      return posities[x][y];
    }

    /**
     * Returnt de selector object
     * @return
     */
    public Selector getSelector(){

        return selektor;
    }

    /**
     * Geeft de grootte van het veld in Y terug
     * @return Grootte van het veld in Y
     */
    public int getVeldGrootY(){

        return veldGroot_y;
    }

    /**
     * Geeft de grootte van het veld in X terug
     * @return Grootte van het veld in X
     */
    public int getVeldGrootX(){

       return veldGroot_x;
    }
}
